First, thanks to all those who responded – I needed the input to help clarify my thoughts on this topic (see Composition Is More Important Than Inheritance to know what I am babbling about).
My point is that, whenever the subject turns to object-oriented programming, the examples always seem (IMHO) to feature inheritance and inheritance alone. Polymorphism is seen only as a useful side-effect of an inheritance-oriented design, while no attention is paid to (a) encapsulation, the basis for all O-O programming, and (b) other programming paradigms, even those conventionally seen in modern O-O programming like interfaces and allomorphism.
Like I have said, we have many tools in our toolbox, so we need to quit viewing the world as a set of nails to be hammered down. Looser coupling through message-passing instead of argument passing, like Alan Kay et.al. have advocated, is one approach likely to bear some exotically useful fruit. Personally, I have been working through Mark Jason Dominus's Higher-Order Perl, which reveals how techniques developed by LISP and functional programmers are of use to Perl programmers. For that matter, I was able last week to (manually) apply memoization to a VB6 routine thereby dropping the average execution time of the routine by 90%, so the lessons therein are not limited to Perl programmers.
As far as the software on CPAN goes, I am sure that just like my software, some of the designs could use improvement. However, my CPAN point was that the "things" in the solution domain do not all constitute a single, well-ordered tree (or even a forest of such trees). To me, solution domains instead resemble a mixed area, partly forested (high use of inheritance), but mostly a grassy plain with some trees scattered amongst the grasses. To stretch the metaphor past the breaking point, the methods (pun intended) for feeding horses and cattle (grasses/encapsulation) are necessarily different from the methods used in building country cabins (rule-based systems), which are different yet from the methods for maintaining fish and other water creatures (functional programming) (and so on). CPAN possesses a large subset of the infrastructure needed for building modern-day software, so (IMHO) it resembles the software engineering solution domain.
We have a large software engineering toolkit – let's use all of it rather than confining ourselves to the hammers and the screwdrivers. One way to explore the toolkit is to learn a language that is specialized for a certain solution domain. For example, it pays to learn regular expressions thoroughly, as no matter what problem domain you write programs for, you will still have to deal with a representation of your data and your program. Regular expressions make many problems in manipulating data&program representations (whether text, AST, or whatever) much more tractable (no surprise to Perl programmers).
Another solution set that is currently hot, Domain-Specific Languages, is actually just Little Languages all over again – DSLs owe much to the Unix Little Language tools YACC, eqn, pic, etc., which themselves owe much to the ease of building little languages when you have tools (like compiler-compilers) for easily building little languages. (YACC and its ilk represent an interesting case of bootstrapping.)
A software engineer's toolbox is so large that you may never explore the whole thing, even over the course of your whole career – but it pays and pays to explore the tools you need to make your programs faster, better, and cheaper. For example, if you have ever built a program to verify data, whether it is postal addresses, CAD data, or what-have-you, you have probably built some kind of expert system engine inside of the program. (This reminds of the quote about every large program having a badly-written Common LISP interpreter inside.)
Inheritance is not the only tool we have when composing programs (although it can be very useful). Perl 6 should be very interesting, as it brings (more of) the benefits of LISP and functional programming to a wider, conventional-syntax-using, audience. (Perl 5 already has closures, anonymous functions, (nearly) first-class-object regexes, along with the other functionality that enabled a not-too-wordy implementation (sic) for Higher-Order Perl.) As far as I know, Perl 6 will bring the most programming paradigms together under one roof of any mainstream language (and it seems to me to have a logical, consistent design to boot).
So, remember as you compose your programs – there are more notes than inheritance and more chord progressions than polymorphism in your program composition toolbox.